// 所有钩子都提供额外的拦截器API
// call:(...args) => void当你的钩子触发之前,(就是call()之前),就会触发这个函数,你可以访问钩子的参数.多个钩子执行一次
// tap: (tap: Tap) => void 每个钩子执行之前(多个钩子执行多个),就会触发这个函数
// register:(tap: Tap) => Tap | undefined 每添加一个Tap都会触发 你interceptor上的register,你下一个拦截器的register 函数得到的参数 取决于你上一个register返回的值,所以你最好返回一个 tap 钩子.
// Context(上下文) 插件和拦截器都可以选择加入一个可选的 context对象, 这个可以被用于传递随意的值到队列中的插件和拦截器


let {SyncHook} = require('tapable');
const syncHook = new SyncHook(['name','age']);
debugger
syncHook.intercept({
    // 注册拦截器
    register(tapInfo){//每当订阅一个新的事件函数就会触发
        console.log(`拦截器1 register`,tapInfo.name);
        return tapInfo;
    },
    tap(tapInfo){//每当一个事件函数执行了就会触发
        console.log(`拦截器1 tap`,tapInfo.name);
    },
    call(name,age){//每次调用call会触发一次
        console.log(`拦截器1 call`,name,age);
    }
});
syncHook.intercept({
    register(tapInfo){
        console.log(`拦截器2 register`,tapInfo.name);
        return tapInfo;
    },
    tap(tapInfo){
        console.log(`拦截器2 tap`,tapInfo.name);
    },
    call(name,age){
        console.log(`拦截器2 call`,name,age);
    }
});

syncHook.tap('事件函数A',(name,age)=>{
  console.log('事件函数A',name,age);
})
syncHook.tap('事件函数B',(name,age)=>{
    console.log('事件函数B',name,age);
})
debugger
syncHook.call('zhufeng',12);
/* 
输出==>
拦截器1 register 事件函数A
拦截器2 register 事件函数A
拦截器1 register 事件函数B
拦截器2 register 事件函数B
拦截器1 call zhufeng 12
拦截器2 call zhufeng 12
拦截器1 tap 事件函数A
拦截器2 tap 事件函数A
事件函数A zhufeng 12
拦截器1 tap 事件函数B
拦截器2 tap 事件函数B
事件函数B zhufeng 12
 */

/* (function anonymous(name, age) {
    var _x = this._x;
    var _taps = this.taps;
    var _interceptors = this.interceptors;
    _interceptors[0].call(name, age);
    _interceptors[1].call(name, age);
    
    var _tap0 = _taps[0];
    _interceptors[0].tap(_tap0);
    _interceptors[1].tap(_tap0);
    var _fn0 = _x[0];
    _fn0(name, age);
    
    var _tap1 = _taps[1];
    _interceptors[0].tap(_tap1);
    _interceptors[1].tap(_tap1);
    var _fn1 = _x[1];
    _fn1(name, age);
}) */